home *** CD-ROM | disk | FTP | other *** search
/ Aminet 51 / Aminet 51 (2002)(GTI - Schatztruhe)[!][Oct 2002].iso / Aminet / gfx / fract / FlashMandelWOS.lha / FlashMandel / Developer / Modules / React / FM_PalettePref_React.c < prev    next >
Encoding:
C/C++ Source or Header  |  2002-08-02  |  28.1 KB  |  862 lines
  1. /*
  2.  *  FM_PalettePrefs_React.c
  3.  *
  4.  *  requester for palette-prefs with reaction-support
  5.  *  $VER: V2.1, 08.06.2002
  6.  *  Coded by Edgar Schwan
  7.  */
  8.  
  9. #include <intuition/gadgetclass.h>
  10. #include <intuition/classusr.h>
  11. #include <intuition/screens.h>
  12. #include <classes/window.h>
  13. #include <classes/arexx.h>
  14. #include <gadgets/palette.h>
  15. #include <gadgets/slider.h>
  16. #include <gadgets/integer.h>
  17.  
  18. #include <clib/intuition_protos.h>
  19. #include <clib/graphics_protos.h>
  20. #include <clib/exec_protos.h>
  21. #include <clib/resource_protos.h>
  22. #include <clib/locale_protos.h>
  23. #include <clib/dos_protos.h>
  24. #include <clib/alib_protos.h>
  25.  
  26. #include <pragmas/intuition_pragmas.h>
  27. #include <pragmas/graphics_pragmas.h>
  28. #include <pragmas/exec_pragmas.h>
  29. #include <pragmas/resource_pragmas.h>
  30. #include <pragmas/locale_pragmas.h>
  31. #include <pragmas/dos_pragmas.h>
  32.  
  33. #include <stdlib.h>
  34. #include <stdio.h>
  35.  
  36. #include "FM_PalettePref_React.h"
  37. #include "FM_ReactionBasics.h"
  38. #include "FM_Reaction.h"
  39. #include "FM_ReactionCD.h"
  40.  
  41. struct ReactWinData *pal_rwd = NULL;
  42.  
  43. #define INTERCONNECTION
  44.  
  45. /* defaults */
  46. #define DEF_PEN        3
  47. #define STARTPEN     (4L)
  48. #define ENDPEN       (255L)
  49. #define MINVALUE     (0L)
  50. #define MAXVALUE     (255L)
  51. #define DELTA        (10L)
  52. #define SHIFT_QUAL (IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT)
  53.  
  54. /* local prototypes */
  55. static void Copy(struct Window *Win, ULONG PenNumber, struct RGB *RGBBuffer);
  56. static void Paste(struct Window *Win, const ULONG PenNumber, struct RGB *RGBBuffer, struct loadrgb *Palette);
  57. static void Swap (struct Window *Win, const ULONG Pen_1, const ULONG Pen_2, struct loadrgb *Palette);
  58. static BOOL Spread (struct Window *Win, const ULONG Pen_1, const ULONG Pen_2, struct loadrgb *Palette);
  59. static void InvertPalette(struct Window *Win, ULONG StartPen, ULONG EndPen, struct loadrgb *Palette);
  60. static void Shl(struct Window *Win, ULONG StartPen, ULONG EndPen, struct loadrgb *Palette);
  61. static void Shr(struct Window *Win, ULONG StartPen, ULONG EndPen, struct loadrgb *Palette);
  62. static void UpdateSliders(ULONG Pen, struct loadrgb *Palette);
  63.  
  64. /* vars */
  65. ULONG RedLevel, GreenLevel, BlueLevel;
  66. ULONG ActPen, OldPen, NewPen, NumColors;
  67. struct RGB UndoRGB = {0}, ClipRGB = {0}, ActRGB = {0};
  68. BOOL Do_Copy, Do_Swap, Do_Spread;
  69.  
  70. /*    Do_PalettePrefRequest(): palette-requester (full handling).
  71.  
  72.         SYNOPSIS: BOOL res = Do_PalettePrefWd
  73.                         (
  74.                         struct Window      *Win;
  75.                         char                  *PubScreenName;
  76.                         WORD                     Left;
  77.                         WORD                    Top;
  78.                         struct loadrgb      *Palette32;
  79.                         );
  80.  
  81.         INPUTS:        Win:
  82.                             Pointer to the parent-window.
  83.  
  84.                         PubScreenName:
  85.                             name of the public-screen, where the window should appear.
  86.  
  87.                         Left:
  88.                             Left edge of palette-window (not supported yet).
  89.  
  90.                         Top:
  91.                             Top edge of palette-window (not supported yet).
  92.  
  93.                         Palette32:
  94.                             pointer to a loadrgb-structure with palette to edit.
  95.  
  96.         RETURNS:        res:
  97.                             Is TRUE, if something changed.
  98. */
  99.  
  100. BOOL Do_PalettePrefRequest(struct Window *Win, char *PubScreenName, WORD Left, WORD Top, struct loadrgb *Palette32)
  101. {
  102. ULONG rc = FALSE, result = RESULT_NOTHING, waitsigs, mask;
  103. ULONG PalLength;
  104. struct loadrgb *WorkPal = NULL;
  105. struct loadrgb *UndoPal = NULL;
  106. struct RGB (*WorkPalColors) [1] = NULL;
  107. struct RGB (*UndoPalColors) [1] = NULL;
  108. struct loadrgb *WorkPalRGB = NULL;
  109. struct DrawInfo *dri = NULL;
  110.  
  111. Do_Copy = FALSE; Do_Swap = FALSE; Do_Spread = FALSE;
  112.  
  113. if (dri = GetScreenDrawInfo(Win->WScreen)) {
  114.     NumColors = 1L << dri->dri_Depth;
  115.     if (OpenPalettePrefWindow(PubScreenName) == TRUE) {
  116.         waitsigs = pal_rwd->RWD_WSignals|SIGBREAKF_CTRL_C;
  117.  
  118.         PalLength = sizeof(struct loadrgb_head) + ((NumColors + 1) * sizeof(struct RGB));
  119.         if (WorkPal = (struct loadrgb *) AllocVec(PalLength, MEMF_PUBLIC|MEMF_CLEAR)) {
  120.             WorkPal->loadrgb_lrgb.lrgb_count = NumColors;
  121.             WorkPal->loadrgb_lrgb.lrgb_first = 0;
  122.             WorkPalColors = (struct RGB (*) [1]) (((ULONG) *(&WorkPal)) + sizeof(struct loadrgb_head));
  123.             if (UndoPal = (struct loadrgb *) AllocVec(PalLength, MEMF_PUBLIC|MEMF_CLEAR)) {
  124.                 UndoPal->loadrgb_lrgb.lrgb_count = NumColors;
  125.                 UndoPal->loadrgb_lrgb.lrgb_first = 0;
  126.                 UndoPalColors = (struct RGB (*) [1]) (((ULONG) *(&UndoPal)) + sizeof(struct loadrgb_head));
  127.                 GetRGB32 (ViewPortAddress(Win)->ColorMap, 0L, NumColors, (ULONG *) WorkPalColors);
  128.                 GetRGB32 (ViewPortAddress(Win)->ColorMap, 0L, NumColors, (ULONG *) UndoPalColors);
  129.  
  130.                 UpdateSliders(DEF_PEN, WorkPal);
  131.                 ActPen = DEF_PEN;
  132.                 rc = TRUE;
  133.  
  134.                 while(result == RESULT_NOTHING) {
  135.                     mask = Wait(waitsigs);
  136. #ifndef NDEBUG
  137.                     printf("mask: %lX\n", mask);
  138. #endif /*NDEBUG*/
  139.                     if (mask & pal_rwd->RWD_WSignals) {
  140.                         result = HandlePalettePrefWindow(Win, Palette32, WorkPal, UndoPal);
  141.                         }
  142.                     if (mask & SIGBREAKF_CTRL_C) {
  143.                         LoadRGB32(ViewPortAddress(Win), (APTR) Palette32);
  144.                         result = RESULT_CANCEL;
  145.                         }
  146.                     }
  147.  
  148.                 FreeVec(UndoPal);
  149.                 } else DisplayError(Win, TXT_ERR_NoMem, 5L);
  150.             FreeVec(WorkPal);
  151.             } else DisplayError(Win, TXT_ERR_NoMem, 5L);
  152.         ClosePalettePrefWindow();
  153.         } else DisplayError(Win, TXT_ERR_Window, 5L);
  154.     FreeScreenDrawInfo(Win->WScreen, dri);
  155.     }
  156. return(rc);
  157. }
  158.  
  159. /*    OpenPalettePrefWindow(): open window of palette-requester.
  160.  
  161.         SYNOPSIS: BOOL res = OpenPalettePrefWindow
  162.                         (
  163.                         char    *PubScreenName;
  164.                         );
  165.  
  166.         INPUTS:        PubScreenName:
  167.                             name of the public-screen, where the window should appear.
  168.  
  169.         RETURNS:        res:
  170.                             TRUE, if successfull.
  171. */
  172.  
  173. BOOL OpenPalettePrefWindow(char *PubScreenName)
  174. {
  175. if (pal_rwd = OpenReactionWindow(WIN_PALETTE_ID, GROUP_Pal_ID, PubScreenName)) {
  176.     SetGadgetAttrs(pal_rwd->RWD_GadgetArray[Pal_PALETTE_1], pal_rwd->RWD_IWindow, NULL,
  177.                         PALETTE_NumColours, NumColors, TAG_DONE);
  178.     SetGadgetAttrs(pal_rwd->RWD_GadgetArray[Pal_PALETTE_1], pal_rwd->RWD_IWindow, NULL,
  179.                         PALETTE_Colour, DEF_PEN, TAG_DONE);
  180.     return(TRUE);
  181.     }
  182. return(FALSE);
  183. }
  184.  
  185. /*    ClosePalettePrefWindow(): close window of palette-requester.
  186.  
  187.         SYNOPSIS: void = ClosePalettePrefWindow
  188.                         (
  189.                         void
  190.                         );
  191.  
  192.         INPUTS:        -
  193.  
  194.         RETURNS:        res:
  195.                             result of the request.
  196. */
  197.  
  198. void ClosePalettePrefWindow(void)
  199. {
  200. CloseReactionWindow(pal_rwd);
  201. }
  202.  
  203. /*    HandlePalettePrefWindow(): Handle the messages of the palette-requester.
  204.  
  205.         SYNOPSIS: LONG = HandlePalettePrefWindow
  206.                         (
  207.                         struct Window    *Win;
  208.                         struct loadrgb    *Palette32;
  209.                         struct loadrgb    *WorkPal;
  210.                         struct loadrgb    *UndoPal;
  211.                         );
  212.  
  213.         INPUTS:        Win:
  214.                             Pointer to a window-structure.
  215.  
  216.                         Palette32:
  217.                             Pointer to a loadrgb-structure of the Palette to edit.
  218.  
  219.                         WorkPal;
  220.                             Pointer to a loadrgb-structure of the Work-Palette.
  221.  
  222.                         UndoPal:
  223.                             Pointer to a loadrgb-structure of the Undo-Palette.
  224.  
  225.         RETURNS:        res:
  226.                             result of messages:    RESULT_NOTHING -> nothing happens.
  227.                                                         RESULT_CANCEL  -> user wants to quit without a change.
  228.                                                         RESULT_OK      -> accept changes and quit.
  229. */
  230.  
  231. LONG HandlePalettePrefWindow(struct Window *Win, struct loadrgb *Palette32, struct loadrgb *WorkPal,
  232.                                       struct loadrgb *UndoPal)
  233. {
  234. ULONG code, result, rc = RESULT_NOTHING;
  235. struct RGB (*Palette32Colors) [1] = (struct RGB (*) [1]) (((ULONG) *(&Palette32)) + sizeof(struct loadrgb_head));
  236. struct RGB (*WorkPalColors) [1] = (struct RGB (*) [1]) (((ULONG) *(&WorkPal)) + sizeof(struct loadrgb_head));
  237. struct RGB (*UndoPalColors) [1] = (struct RGB (*) [1]) (((ULONG) *(&UndoPal)) + sizeof(struct loadrgb_head));
  238.  
  239. while((result = DoMethod(pal_rwd->RWD_WindowObject, WM_HANDLEINPUT, &code)) != WMHI_LASTMSG) {
  240.  
  241. #ifndef NDEBUG
  242.     printf("result: %lX\n", result);
  243. #endif /*NDEBUG*/
  244.  
  245.     switch (result & WMHI_CLASSMASK) {
  246.         case WMHI_CLOSEWINDOW:
  247.             LoadRGB32(ViewPortAddress(Win), (APTR) Palette32);
  248.             rc = RESULT_CANCEL;
  249.             break;
  250.  
  251.         case WMHI_GADGETUP:
  252.             switch (result & RL_GADGETMASK) {
  253.                 case Pal_BUTTON_Accept:
  254.                     GetRGB32(ViewPortAddress(Win)->ColorMap, 0L, NumColors, (ULONG *) Palette32Colors);
  255.                     rc = RESULT_OK;
  256.                     break;
  257.                 case Pal_BUTTON_Reset:
  258.                     LoadRGB32(ViewPortAddress(Win), (APTR) Palette32);
  259.                     GetRGB32(ViewPortAddress(Win)->ColorMap, 0L, NumColors, (ULONG *) WorkPalColors);
  260.                     UpdateSliders(ActPen, WorkPal);
  261.                     break;
  262.                 case Pal_BUTTON_Cancel:
  263.                     LoadRGB32(ViewPortAddress(Win), (APTR) Palette32);
  264.                     rc = RESULT_CANCEL;
  265.                     break;
  266.                 case Pal_BUTTON_Copy:
  267.                     Copy(Win, ActPen, &ClipRGB);
  268.                     Do_Copy = TRUE; Do_Swap = FALSE; Do_Spread = FALSE;
  269.                     break;
  270.                 case Pal_BUTTON_Swap:
  271.                     OldPen = ActPen;
  272.                     Do_Copy = FALSE; Do_Swap = TRUE; Do_Spread = FALSE;
  273.                     break;
  274.                 case Pal_BUTTON_Spread:
  275.                     OldPen = ActPen;
  276.                     Do_Copy = FALSE; Do_Swap = FALSE; Do_Spread = TRUE;
  277.                     break;
  278.                 case Pal_BUTTON_Invert:
  279.                     GetRGB32(ViewPortAddress(Win)->ColorMap, 0L, NumColors, (ULONG *) UndoPalColors);
  280.                     InvertPalette(Win, STARTPEN, NumColors - 1, WorkPal);
  281.                     UpdateSliders(ActPen, WorkPal);
  282.                     break;
  283.                 case Pal_BUTTON_ShiftLeft:
  284.                     GetRGB32(ViewPortAddress(Win)->ColorMap, 0L, NumColors, (ULONG *) UndoPalColors);
  285.                     Shl(Win, STARTPEN, ENDPEN, WorkPal);
  286.                     break;
  287.                 case Pal_BUTTON_ShiftRight:
  288.                     GetRGB32(ViewPortAddress(Win)->ColorMap, 0L, NumColors, (ULONG *) UndoPalColors);
  289.                     Shr(Win, STARTPEN, ENDPEN, WorkPal);
  290.                     break;
  291.                 case Pal_BUTTON_Undo:
  292.                     LoadRGB32(ViewPortAddress(Win), (APTR) UndoPal);
  293.                     GetRGB32(ViewPortAddress(Win)->ColorMap, 0L, NumColors, (ULONG *) WorkPalColors);
  294.                     UpdateSliders(ActPen, WorkPal);
  295.                     break;
  296.                 case Pal_PALETTE_1:
  297.                     GetAttr(PALETTE_Colour, pal_rwd->RWD_GadgetArray[Pal_PALETTE_1], &ActPen);
  298.                     if (Do_Copy == TRUE) {
  299.                         GetRGB32(ViewPortAddress(Win)->ColorMap, 0L, NumColors, (ULONG *) UndoPalColors);
  300.                         Paste(Win, ActPen, &ClipRGB, WorkPal);
  301.                         Do_Copy = FALSE;
  302.                         }
  303.  
  304.                     if (Do_Swap == TRUE) {
  305.                         GetRGB32(ViewPortAddress(Win)->ColorMap, 0L, NumColors, (ULONG *) UndoPalColors);
  306.                         NewPen = ActPen;
  307.                         Swap(Win, OldPen, NewPen, WorkPal);
  308.                         Do_Swap = FALSE;
  309.                         }
  310.  
  311.                     if (Do_Spread == TRUE) {
  312.                         GetRGB32(ViewPortAddress(Win)->ColorMap, 0L, NumColors, (ULONG *) UndoPalColors);
  313.                         NewPen = ActPen;
  314.                         Spread(Win, OldPen, NewPen, WorkPal);
  315.                         Do_Spread = FALSE;
  316.                         }
  317.  
  318.                     UpdateSliders(ActPen, WorkPal);
  319.                     break;
  320.                 case Pal_INTEGER_RedValue:
  321. #ifndef INTERCONNECTION
  322.                     GetRGB32(ViewPortAddress(Win)->ColorMap, 0L, NumColors, (ULONG *) UndoPalColors);
  323.                     GetAttr(INTEGER_Number, pal_rwd->RWD_GadgetArray[Pal_INTEGER_RedValue], &RedLevel);
  324.                     SetGadgetAttrs(pal_rwd->RWD_GadgetArray[Pal_SLIDER_Red], pal_rwd->RWD_IWindow, NULL,
  325.                                         SLIDER_Level, RedLevel, TAG_DONE);
  326.                     WorkPalColors[ActPen]->RGB_Red = RedLevel << 24L;;
  327.                     LoadRGB32(ViewPortAddress(Win), (APTR) WorkPal);
  328.                     break;
  329. #endif /*INTERCONNECTION*/
  330.                 case Pal_SLIDER_Red:
  331.                     GetRGB32(ViewPortAddress(Win)->ColorMap, 0L, NumColors, (ULONG *) UndoPalColors);
  332.                     GetAttr(SLIDER_Level, pal_rwd->RWD_GadgetArray[Pal_SLIDER_Red], &RedLevel);
  333. #ifndef INTERCONNECTION
  334.                     SetGadgetAttrs(pal_rwd->RWD_GadgetArray[Pal_INTEGER_RedValue], pal_rwd->RWD_IWindow, NULL,
  335.                                         INTEGER_Number, RedLevel, TAG_DONE);
  336. #endif /*INTERCONNECTION*/
  337.                     WorkPalColors[ActPen]->RGB_Red = RedLevel << 24L;;
  338.                     LoadRGB32(ViewPortAddress(Win), (APTR) WorkPal);
  339.                     break;
  340.                 case Pal_INTEGER_GreenValue:
  341. #ifndef INTERCONNECTION
  342.                     GetRGB32(ViewPortAddress(Win)->ColorMap, 0L, NumColors, (ULONG *) UndoPalColors);
  343.                     GetAttr(INTEGER_Number, pal_rwd->RWD_GadgetArray[Pal_INTEGER_GreenValue], &GreenLevel);
  344.                     SetGadgetAttrs(pal_rwd->RWD_GadgetArray[Pal_SLIDER_Green], pal_rwd->RWD_IWindow, NULL,
  345.                                         SLIDER_Level, GreenLevel, TAG_DONE);
  346.                     WorkPalColors[ActPen]->RGB_Green = GreenLevel << 24L;;
  347.                     LoadRGB32(ViewPortAddress(Win), (APTR) WorkPal);
  348.                     break;
  349. #endif /*INTERCONNECTION*/
  350.                 case Pal_SLIDER_Green:
  351.                     GetRGB32(ViewPortAddress(Win)->ColorMap, 0L, NumColors, (ULONG *) UndoPalColors);
  352.                     GetAttr(SLIDER_Level, pal_rwd->RWD_GadgetArray[Pal_SLIDER_Green], &GreenLevel);
  353. #ifndef INTERCONNECTION
  354.                     SetGadgetAttrs(pal_rwd->RWD_GadgetArray[Pal_INTEGER_GreenValue], pal_rwd->RWD_IWindow, NULL,
  355.                                         INTEGER_Number, GreenLevel, TAG_DONE);
  356. #endif /*INTERCONNECTION*/
  357.                     WorkPalColors[ActPen]->RGB_Green = GreenLevel << 24L;;
  358.                     LoadRGB32(ViewPortAddress(Win), (APTR) WorkPal);
  359.                     break;
  360.                 case Pal_INTEGER_BlueValue:
  361. #ifndef INTERCONNECTION
  362.                     GetRGB32(ViewPortAddress(Win)->ColorMap, 0L, NumColors, (ULONG *) UndoPalColors);
  363.                     GetAttr(INTEGER_Number, pal_rwd->RWD_GadgetArray[Pal_INTEGER_BlueValue], &BlueLevel);
  364.                     SetGadgetAttrs(pal_rwd->RWD_GadgetArray[Pal_SLIDER_Blue], pal_rwd->RWD_IWindow, NULL,
  365.                                         SLIDER_Level, BlueLevel, TAG_DONE);
  366.                     WorkPalColors[ActPen]->RGB_Blue = BlueLevel << 24L;;
  367.                     LoadRGB32(ViewPortAddress(Win), (APTR) WorkPal);
  368.                     break;
  369. #endif /*INTERCONNECTION*/
  370.                 case Pal_SLIDER_Blue:
  371.                     GetRGB32(ViewPortAddress(Win)->ColorMap, 0L, NumColors, (ULONG *) UndoPalColors);
  372.                     GetAttr(SLIDER_Level, pal_rwd->RWD_GadgetArray[Pal_SLIDER_Blue], &BlueLevel);
  373. #ifndef INTERCONNECTION
  374.                     SetGadgetAttrs(pal_rwd->RWD_GadgetArray[Pal_INTEGER_BlueValue], pal_rwd->RWD_IWindow, NULL,
  375.                                         INTEGER_Number, BlueLevel, TAG_DONE);
  376. #endif /*INTERCONNECTION*/
  377.                     WorkPalColors[ActPen]->RGB_Blue = BlueLevel << 24L;;
  378.                     LoadRGB32(ViewPortAddress(Win), (APTR) WorkPal);
  379.                     break;
  380. #ifndef NDEBUG
  381.                 default:
  382.                     printf("unknown result: %lX\nunknown gadget: %lX\n", result, result & WMHI_GADGETMASK);
  383.                     DisplayBeep(NULL);
  384.                     break;
  385. #endif /*NDEBUG*/
  386.                 }
  387.             break;
  388.  
  389.         case WMHI_ICONIFY:
  390.             DoMethod(pal_rwd->RWD_WindowObject, WM_ICONIFY);
  391.             GetAttr(WINDOW_Window, pal_rwd->RWD_WindowObject, (ULONG *) &pal_rwd->RWD_IWindow);
  392.             break;
  393.  
  394.         case WMHI_UNICONIFY:
  395.             DoMethod(pal_rwd->RWD_WindowObject, WM_OPEN);
  396.             GetAttr(WINDOW_Window, pal_rwd->RWD_WindowObject, (ULONG *) &pal_rwd->RWD_IWindow);
  397.             break;
  398.  
  399.         case WMHI_RAWKEY:
  400.             {
  401.             struct InputEvent *ie = NULL;
  402.             GetAttr(WINDOW_InputEvent, pal_rwd->RWD_WindowObject, (ULONG *) &ie);
  403. #if 0
  404. printf("Key: %ld, Qualifier: %ld\n", result & WMHI_KEYMASK, ie->ie_Qualifier);
  405. #endif
  406.             switch (result & WMHI_KEYMASK) {
  407.                 case 69:   /* esc */
  408.                     LoadRGB32(ViewPortAddress(Win), (APTR) Palette32);
  409.                     rc = RESULT_CANCEL;
  410.                     break;
  411.                 case 18:   /* e */
  412.                     if (ie->ie_Qualifier & SHIFT_QUAL) {    /* red - delta */
  413.                         RedLevel = WorkPalColors[ActPen]->RGB_Red >> 24L;
  414.                         if (RedLevel > MINVALUE) {
  415.                             GetRGB32(ViewPortAddress(Win)->ColorMap, 0L, NumColors, (ULONG *) UndoPalColors);
  416.                             RedLevel = (RedLevel < (MINVALUE + DELTA)) ? MINVALUE : RedLevel - DELTA;
  417.                             SetGadgetAttrs(pal_rwd->RWD_GadgetArray[Pal_SLIDER_Red], pal_rwd->RWD_IWindow, NULL,
  418.                                                 SLIDER_Level, RedLevel, TAG_DONE);
  419.                             WorkPalColors[ActPen]->RGB_Red = RedLevel << 24L;
  420.                             LoadRGB32(ViewPortAddress (Win), (APTR) WorkPal);
  421.                             }
  422.                         }
  423.                     else {                                            /* red - 1 */
  424.                         RedLevel = WorkPalColors[ActPen]->RGB_Red >> 24L;
  425.                         if (RedLevel > MINVALUE) {
  426.                             GetRGB32(ViewPortAddress(Win)->ColorMap, 0L, NumColors, (ULONG *) UndoPalColors);
  427.                             RedLevel = (RedLevel < (MINVALUE + 1)) ? MINVALUE : RedLevel - 1;
  428.                             SetGadgetAttrs(pal_rwd->RWD_GadgetArray[Pal_SLIDER_Red], pal_rwd->RWD_IWindow, NULL,
  429.                                                 SLIDER_Level, RedLevel, TAG_DONE);
  430.                             WorkPalColors[ActPen]->RGB_Red = RedLevel << 24L;
  431.                             LoadRGB32(ViewPortAddress (Win), (APTR) WorkPal);
  432.                             }
  433.                         }
  434.                     break;
  435.                 case 20:   /* t */
  436.                     if (ie->ie_Qualifier & SHIFT_QUAL) {    /* red + delta */
  437.                         RedLevel = WorkPalColors[ActPen]->RGB_Red >> 24L;
  438.                         if (RedLevel < MAXVALUE) {
  439.                             GetRGB32(ViewPortAddress(Win)->ColorMap, 0L, NumColors, (ULONG *) UndoPalColors);
  440.                             RedLevel = (RedLevel > (MAXVALUE - DELTA)) ? MAXVALUE : RedLevel + DELTA;
  441.                             SetGadgetAttrs(pal_rwd->RWD_GadgetArray[Pal_SLIDER_Red], pal_rwd->RWD_IWindow, NULL,
  442.                                                 SLIDER_Level, RedLevel, TAG_DONE);
  443.                             WorkPalColors[ActPen]->RGB_Red = RedLevel << 24L;
  444.                             LoadRGB32(ViewPortAddress (Win), (APTR) WorkPal);
  445.                             }
  446.                         }
  447.                     else {                                            /* red + 1 */
  448.                         RedLevel = WorkPalColors[ActPen]->RGB_Red >> 24L;
  449.                         if (RedLevel < MAXVALUE) {
  450.                             GetRGB32(ViewPortAddress(Win)->ColorMap, 0L, NumColors, (ULONG *) UndoPalColors);
  451.                             RedLevel = (RedLevel > (MAXVALUE - 1)) ? MAXVALUE : RedLevel + 1;
  452.                             SetGadgetAttrs(pal_rwd->RWD_GadgetArray[Pal_SLIDER_Red], pal_rwd->RWD_IWindow, NULL,
  453.                                                 SLIDER_Level, RedLevel, TAG_DONE);
  454.                             WorkPalColors[ActPen]->RGB_Red = RedLevel << 24L;
  455.                             LoadRGB32(ViewPortAddress (Win), (APTR) WorkPal);
  456.                             }
  457.                         }
  458.                     break;
  459.                 case 35:   /* f */
  460.                     if (ie->ie_Qualifier & SHIFT_QUAL) {    /* green - delta */
  461.                         GreenLevel = WorkPalColors[ActPen]->RGB_Green >> 24L;
  462.                         if (GreenLevel > MINVALUE) {
  463.                             GetRGB32(ViewPortAddress(Win)->ColorMap, 0L, NumColors, (ULONG *) UndoPalColors);
  464.                             GreenLevel = (GreenLevel < (MINVALUE + DELTA)) ? MINVALUE : GreenLevel - DELTA;
  465.                             SetGadgetAttrs(pal_rwd->RWD_GadgetArray[Pal_SLIDER_Green], pal_rwd->RWD_IWindow, NULL,
  466.                                                 SLIDER_Level, GreenLevel, TAG_DONE);
  467.                             WorkPalColors[ActPen]->RGB_Green = GreenLevel << 24L;
  468.                             LoadRGB32(ViewPortAddress (Win), (APTR) WorkPal);
  469.                             }
  470.                         }
  471.                     else {                                            /* green - 1 */
  472.                         if (GreenLevel > MINVALUE) {
  473.                             GetRGB32(ViewPortAddress(Win)->ColorMap, 0L, NumColors, (ULONG *) UndoPalColors);
  474.                             GreenLevel = (GreenLevel < (MINVALUE + 1)) ? MINVALUE : GreenLevel - 1;
  475.                             SetGadgetAttrs(pal_rwd->RWD_GadgetArray[Pal_SLIDER_Green], pal_rwd->RWD_IWindow, NULL,
  476.                                                 SLIDER_Level, GreenLevel, TAG_DONE);
  477.                             WorkPalColors[ActPen]->RGB_Green = GreenLevel << 24L;
  478.                             LoadRGB32(ViewPortAddress (Win), (APTR) WorkPal);
  479.                             }
  480.                         }
  481.                     break;
  482.                 case 37:   /* h */
  483.                     if (ie->ie_Qualifier & SHIFT_QUAL) {    /* green + delta */
  484.                         GreenLevel = WorkPalColors[ActPen]->RGB_Green >> 24L;
  485.                         if (GreenLevel < MAXVALUE) {
  486.                             GetRGB32(ViewPortAddress(Win)->ColorMap, 0L, NumColors, (ULONG *) UndoPalColors);
  487.                             GreenLevel = (GreenLevel > (MAXVALUE - DELTA)) ? MAXVALUE : GreenLevel + DELTA;
  488.                             SetGadgetAttrs(pal_rwd->RWD_GadgetArray[Pal_SLIDER_Green], pal_rwd->RWD_IWindow, NULL,
  489.                                                 SLIDER_Level, GreenLevel, TAG_DONE);
  490.                             WorkPalColors[ActPen]->RGB_Green = GreenLevel << 24L;
  491.                             LoadRGB32(ViewPortAddress (Win), (APTR) WorkPal);
  492.                             }
  493.                         }
  494.                     else {                                            /* green + 1 */
  495.                         GreenLevel = WorkPalColors[ActPen]->RGB_Green >> 24L;
  496.                         if (GreenLevel < MAXVALUE) {
  497.                             GetRGB32(ViewPortAddress(Win)->ColorMap, 0L, NumColors, (ULONG *) UndoPalColors);
  498.                             GreenLevel = (GreenLevel > (MAXVALUE - 1)) ? MAXVALUE : GreenLevel + 1;
  499.                             SetGadgetAttrs(pal_rwd->RWD_GadgetArray[Pal_SLIDER_Green], pal_rwd->RWD_IWindow, NULL,
  500.                                                 SLIDER_Level, GreenLevel, TAG_DONE);
  501.                             WorkPalColors[ActPen]->RGB_Green = GreenLevel << 24L;
  502.                             LoadRGB32(ViewPortAddress (Win), (APTR) WorkPal);
  503.                             }
  504.                         }
  505.                     break;
  506.                 case 52:   /* v */
  507.                     if (ie->ie_Qualifier & SHIFT_QUAL) {    /* blue - delta */
  508.                         BlueLevel = WorkPalColors[ActPen]->RGB_Blue >> 24L;
  509.                         if (BlueLevel > MINVALUE) {
  510.                             GetRGB32(ViewPortAddress(Win)->ColorMap, 0L, NumColors, (ULONG *) UndoPalColors);
  511.                             BlueLevel = (BlueLevel < (MINVALUE + DELTA)) ? MINVALUE : BlueLevel - DELTA;
  512.                             SetGadgetAttrs(pal_rwd->RWD_GadgetArray[Pal_SLIDER_Blue], pal_rwd->RWD_IWindow, NULL,
  513.                                                 SLIDER_Level, BlueLevel, TAG_DONE);
  514.                             WorkPalColors[ActPen]->RGB_Blue = BlueLevel << 24L;
  515.                             LoadRGB32(ViewPortAddress (Win), (APTR) WorkPal);
  516.                             }
  517.                         }
  518.                     else {                                            /* blue - 1 */
  519.                         if (BlueLevel > MINVALUE) {
  520.                             GetRGB32(ViewPortAddress(Win)->ColorMap, 0L, NumColors, (ULONG *) UndoPalColors);
  521.                             BlueLevel = (BlueLevel < (MINVALUE + 1)) ? MINVALUE : BlueLevel - 1;
  522.                             SetGadgetAttrs(pal_rwd->RWD_GadgetArray[Pal_SLIDER_Blue], pal_rwd->RWD_IWindow, NULL,
  523.                                                 SLIDER_Level, BlueLevel, TAG_DONE);
  524.                             WorkPalColors[ActPen]->RGB_Blue = BlueLevel << 24L;
  525.                             LoadRGB32(ViewPortAddress (Win), (APTR) WorkPal);
  526.                             }
  527.                         }
  528.                     break;
  529.                 case 54:   /* n */
  530.                     if (ie->ie_Qualifier & SHIFT_QUAL) {    /* blue + delta */
  531.                         BlueLevel = WorkPalColors[ActPen]->RGB_Blue >> 24L;
  532.                         if (BlueLevel < MAXVALUE) {
  533.                             GetRGB32(ViewPortAddress(Win)->ColorMap, 0L, NumColors, (ULONG *) UndoPalColors);
  534.                             BlueLevel = (BlueLevel > (MAXVALUE - DELTA)) ? MAXVALUE : BlueLevel + DELTA;
  535.                             SetGadgetAttrs(pal_rwd->RWD_GadgetArray[Pal_SLIDER_Blue], pal_rwd->RWD_IWindow, NULL,
  536.                                                 SLIDER_Level, BlueLevel, TAG_DONE);
  537.                             WorkPalColors[ActPen]->RGB_Blue = BlueLevel << 24L;
  538.                             LoadRGB32(ViewPortAddress (Win), (APTR) WorkPal);
  539.                             }
  540.                         }
  541.                     else {                                            /* blue + 1 */
  542.                         BlueLevel = WorkPalColors[ActPen]->RGB_Blue >> 24L;
  543.                         if (BlueLevel < MAXVALUE) {
  544.                             GetRGB32(ViewPortAddress(Win)->ColorMap, 0L, NumColors, (ULONG *) UndoPalColors);
  545.                             BlueLevel = (BlueLevel > (MAXVALUE - 1)) ? MAXVALUE : BlueLevel + 1;
  546.                             SetGadgetAttrs(pal_rwd->RWD_GadgetArray[Pal_SLIDER_Blue], pal_rwd->RWD_IWindow, NULL,
  547.                                                 SLIDER_Level, BlueLevel, TAG_DONE);
  548.                             WorkPalColors[ActPen]->RGB_Blue = BlueLevel << 24L;
  549.                             LoadRGB32(ViewPortAddress (Win), (APTR) WorkPal);
  550.                             }
  551.                         }
  552.                     break;
  553.                 }
  554.             break;
  555.             }
  556.  
  557. #ifndef NDEBUG
  558.         default:
  559.             printf("unknown result: %lX\nunknown class: %lX\n", result, result & WMHI_CLASSMASK);
  560.             DisplayBeep(NULL);
  561.             break;
  562. #endif /*NDEBUG*/
  563.         }
  564.     }
  565. return(rc);
  566. }
  567.  
  568. /* Copy: Copy the color-values of an desired pen to a RGB-structure.
  569.  
  570.         SYNOPSIS: static void = Copy
  571.                         (
  572.                         struct Window *Win;
  573.                         ULONG                PenNumber;
  574.                         struct RGB      *RGBColor;
  575.                         );
  576.  
  577.         INPUTS:        Win:
  578.                             Pointer to a window-structure.
  579.  
  580.                         PenNumber:
  581.                             Number of the pen to copy.
  582.  
  583.                         RGBColor:
  584.                             Pointer to a RGB-structure to store th color-values.
  585.  
  586.         RETURNS:        - 
  587. */
  588.  
  589. static void Copy(struct Window *Win, ULONG PenNumber, struct RGB *RGBColor)
  590. {
  591. GetRGB32 (ViewPortAddress(Win)->ColorMap, PenNumber, 1L, (ULONG *) RGBColor);
  592. }
  593.  
  594. /* Paste: store the color-values of a RGB-structure to a pen of a palette.
  595.  
  596.         SYNOPSIS: static void = Paste
  597.                         (
  598.                         struct Window      *Win;
  599.                         const ULONG            PenNumber;
  600.                         struct RGB          *RGBColor;
  601.                         struct loadrgb      *Palette;
  602.                         );
  603.  
  604.         INPUTS:        Win:
  605.                             Pointer to a window-structure.
  606.  
  607.                         PenNumber:
  608.                             Number of the pen to copy.
  609.  
  610.                         RGBColor:
  611.                             Pointer to a RGB-structure, which contains the color-values.
  612.  
  613.                         Palette:
  614.                             Pointer to a loadrgb-structure to edit.
  615.  
  616.         RETURNS:        - 
  617. */
  618.  
  619. static void Paste(struct Window *Win, const ULONG PenNumber, struct RGB *RGBColor, struct loadrgb *Palette)
  620. {
  621. struct RGB (*PalColors) [1] = (struct RGB (*) [1]) (((ULONG) *(&Palette)) + sizeof(struct loadrgb_head));
  622.  
  623. PalColors[PenNumber]->RGB_Red = RGBColor->RGB_Red;
  624. PalColors[PenNumber]->RGB_Green = RGBColor->RGB_Green;
  625. PalColors[PenNumber]->RGB_Blue = RGBColor->RGB_Blue;
  626. LoadRGB32 (ViewPortAddress(Win), (ULONG *) Palette);
  627. }
  628.  
  629. /* Swap: Swap two colors of a palette.
  630.  
  631.         SYNOPSIS: static void = Swap
  632.                         (
  633.                         struct Window      *Win;
  634.                         const ULONG            Pen_1;
  635.                         const ULONG            Pen_2;
  636.                         struct loadrgb      *Palette;
  637.                         );
  638.  
  639.         INPUTS:        Win:
  640.                             Pointer to a window-structure.
  641.  
  642.                         Pen_1:
  643.                             Number of the first pen.
  644.  
  645.                         Pen_2:
  646.                             Number of the second pen.
  647.  
  648.                         Palette:
  649.                             Pointer to a loadrgb-structure to edit.
  650.  
  651.         RETURNS:        - 
  652. */
  653.  
  654. static void Swap(struct Window *Win, const ULONG Pen_1, const ULONG Pen_2, struct loadrgb *Palette)
  655. {
  656. struct RGB TmpRGB1, TmpRGB2;
  657.  
  658. Copy (Win, Pen_1, &TmpRGB1);
  659. Copy (Win, Pen_2, &TmpRGB2);
  660. Paste (Win, Pen_1, &TmpRGB2, Palette);
  661. Paste (Win, Pen_2, &TmpRGB1, Palette);
  662. }
  663.  
  664. /*    Spread(): Create a range of colors between two pens.
  665.  
  666.         SYNOPSIS: static BOOL res = Spread
  667.                         (
  668.                         struct Window      *Win;
  669.                         const ULONG            OldPen;
  670.                         const ULONG            NewPen;
  671.                         struct loadrgb      *Palette;
  672.                         );
  673.  
  674.         INPUTS:        Win:
  675.                             Pointer to a window-structure.
  676.  
  677.                         OldPen:
  678.                             Number of the old pen.
  679.  
  680.                         NewPen:
  681.                             Number of the new Pen.
  682.  
  683.                         Palette:
  684.                             Pointer to a loadrgb-structure of the palette to edit.
  685.  
  686.         RETURNS:        res: 
  687.                             TRUE, if spread failed.
  688. */
  689.  
  690. static BOOL Spread(struct Window *Win, const ULONG OldPen, const ULONG NewPen, struct loadrgb *Palette)
  691. {
  692. struct RGB (*PalColors) [1] = (struct RGB (*) [1]) (((ULONG) *(&Palette)) + sizeof(struct loadrgb_head));
  693. const ULONG StartPen = MIN (OldPen, NewPen), EndPen = MAX (OldPen, NewPen);
  694. const ULONG  Range = EndPen - StartPen;
  695. LONG RedStep, GreenStep, BlueStep;
  696. ULONG Index, RLevel, GLevel, BLevel;
  697.  
  698. if (Range < 2L) return(TRUE);
  699.  
  700. RLevel = PalColors[StartPen]->RGB_Red >> 8L;
  701. GLevel = PalColors[StartPen]->RGB_Green >> 8L;
  702. BLevel = PalColors[StartPen]->RGB_Blue >> 8L;
  703.  
  704. RedStep = (LONG) PalColors[EndPen]->RGB_Red >> 8L;
  705. GreenStep = (LONG) PalColors[EndPen]->RGB_Green >> 8L;
  706. BlueStep = (LONG) PalColors[EndPen]->RGB_Blue >> 8L;
  707.  
  708. RedStep    -= (LONG) RLevel;
  709. GreenStep  -= (LONG) GLevel;
  710. BlueStep   -= (LONG) BLevel;
  711.  
  712. RedStep    /= (LONG) Range;
  713. GreenStep  /= (LONG) Range;
  714. BlueStep   /= (LONG) Range;
  715.  
  716. for (Index = (StartPen + 1L); Index < EndPen; Index++) {
  717.     RLevel += RedStep;
  718.     GLevel += GreenStep;
  719.     BLevel += BlueStep;
  720.  
  721.     PalColors[Index]->RGB_Red = RLevel << 8L;
  722.     PalColors[Index]->RGB_Green = GLevel << 8L;
  723.     PalColors[Index]->RGB_Blue = BLevel << 8L;
  724.     }
  725.  
  726. LoadRGB32 (ViewPortAddress (Win), (APTR) Palette);
  727.  
  728. return(FALSE);
  729. }
  730.  
  731. /*    InvertPalette(): Invert the colors of a palette.
  732.  
  733.         SYNOPSIS: static void = InvertPalette
  734.                         (
  735.                         struct Window      *Win;
  736.                         ULONG                    StartPen;
  737.                         ULONG                    EndPen;
  738.                         struct loadrgb      *Palette;
  739.                         );
  740.  
  741.         INPUTS:        Win:
  742.                             Pointer to a window-structure.
  743.  
  744.                         StartPen:
  745.                             Number of the first pen.
  746.  
  747.                         EndPen:
  748.                             Number of the last Pen.
  749.  
  750.                         Palette:
  751.                             Pointer to a loadrgb-structure of the palette to edit.
  752.  
  753.         RETURNS:        -
  754. */
  755.  
  756. static void InvertPalette(struct Window *Win, ULONG StartPen, ULONG EndPen, struct loadrgb *Palette)
  757. {
  758. while (StartPen < EndPen) Swap(Win, StartPen++, EndPen--, Palette);
  759. }
  760.  
  761. /*    Shl(): Shift palette-colors to left.
  762.  
  763.         SYNOPSIS: static void = Shl
  764.                         (
  765.                         struct Window      *Win;
  766.                         ULONG                    StartPen;
  767.                         ULONG                    EndPen;
  768.                         struct loadrgb      *Palette;
  769.                         );
  770.  
  771.         INPUTS:        Win:
  772.                             Pointer to a window-structure.
  773.  
  774.                         StartPen:
  775.                             Number of the first pen.
  776.  
  777.                         EndPen:
  778.                             Number of the last Pen.
  779.  
  780.                         Palette:
  781.                             Pointer to a loadrgb-structure of the palette to edit.
  782.  
  783.         RETURNS:        -
  784. */
  785.  
  786. static void Shl(struct Window *Win, ULONG StartPen, ULONG EndPen, struct loadrgb *Palette)
  787. {
  788. while (StartPen < EndPen) Swap(Win, StartPen, StartPen + 1, Palette), StartPen++;
  789. }
  790.  
  791. /*    Shr(): Shift palette-colors to right.
  792.  
  793.         SYNOPSIS: static void = Shr
  794.                         (
  795.                         struct Window      *Win;
  796.                         ULONG                    StartPen;
  797.                         ULONG                    EndPen;
  798.                         struct loadrgb      *Palette;
  799.                         );
  800.  
  801.         INPUTS:        Win:
  802.                             Pointer to a window-structure.
  803.  
  804.                         StartPen:
  805.                             Number of the first pen.
  806.  
  807.                         EndPen:
  808.                             Number of the last Pen.
  809.  
  810.                         Palette:
  811.                             Pointer to a loadrgb-structure of the palette to edit.
  812.  
  813.         RETURNS:        res: -
  814. */
  815.  
  816. static void Shr(struct Window *Win, ULONG StartPen, ULONG EndPen, struct loadrgb *Palette)
  817. {
  818. while (EndPen > StartPen) Swap(Win, EndPen, EndPen - 1, Palette), EndPen--;
  819. }
  820.  
  821. /*    UpdateSliders(): Update slider-positions and integer-values.
  822.  
  823.         SYNOPSIS: static void = UpdateSliders
  824.                         (
  825.                         ULONG                    Pen;
  826.                         struct loadrgb   *Palette;
  827.                         );
  828.  
  829.         INPUTS:        Pen:
  830.                             Number of desired pen.
  831.  
  832.                         Palette:
  833.                             Pointer to a loadrgb-structure of the palette to use.
  834.  
  835.         RETURNS:        -
  836. */
  837.  
  838. static void UpdateSliders(ULONG Pen, struct loadrgb *Palette)
  839. {
  840. struct RGB (*PalColors) [1] = (struct RGB (*) [1]) (((ULONG) *(&Palette)) + sizeof(struct loadrgb_head));
  841.  
  842. RedLevel = (PalColors[Pen]->RGB_Red >> 24L);
  843. GreenLevel = (PalColors[Pen]->RGB_Green >> 24L);
  844. BlueLevel = (PalColors[Pen]->RGB_Blue >> 24L);
  845.  
  846. SetGadgetAttrs(pal_rwd->RWD_GadgetArray[Pal_SLIDER_Red], pal_rwd->RWD_IWindow, NULL,
  847.                     SLIDER_Level, RedLevel, TAG_DONE);
  848. SetGadgetAttrs(pal_rwd->RWD_GadgetArray[Pal_SLIDER_Green], pal_rwd->RWD_IWindow, NULL,
  849.                     SLIDER_Level, GreenLevel, TAG_DONE);
  850. SetGadgetAttrs(pal_rwd->RWD_GadgetArray[Pal_SLIDER_Blue], pal_rwd->RWD_IWindow, NULL,
  851.                     SLIDER_Level, BlueLevel, TAG_DONE);
  852.  
  853. #ifndef INTERCONNECTION
  854. SetGadgetAttrs(pal_rwd->RWD_GadgetArray[Pal_INTEGER_RedValue], pal_rwd->RWD_IWindow, NULL,
  855.                     INTEGER_Number, RedLevel, TAG_DONE);
  856. SetGadgetAttrs(pal_rwd->RWD_GadgetArray[Pal_INTEGER_GreenValue], pal_rwd->RWD_IWindow, NULL,
  857.                     INTEGER_Number, GreenLevel, TAG_DONE);
  858. SetGadgetAttrs(pal_rwd->RWD_GadgetArray[Pal_INTEGER_BlueValue], pal_rwd->RWD_IWindow, NULL,
  859.                     INTEGER_Number, BlueLevel, TAG_DONE);
  860. #endif /*INTERCONNECTION*/
  861. }
  862.